/*----------------------------------------------------------------------------------------------------
** Created by        : [zhaoyang]
** Created date      : 2022-08-26
** Version           : 1.0
** Descriptions      : 系统运行管理
**---------------------------------------------------------------------------------------------------*/

#include <stdbool.h>
#include <stdint.h>
#include "nrf_gpio.h"
#include "nrf.h"
#include "nrf_log.h"
#include "nrf_delay.h"
#include "wm8978.h"
#include "nrf_drv_i2s.h"
#include "player.h"
                              
#include "FreeRTOS.h"
#include "task.h"
#include "timers.h"
#include "semphr.h"
                              
#include "flash_manage.h"

#include "nrf_rtc.h"
#include "nrf_drv_timer.h"
#include "ble_date_time.h"

#include "w25q128.h"
#include "data_handle.h"
#include "algo_distance.h"
#include "m_data_handle.h"

#include "hr_task.h"
#include "bsp_btn_ble.h"
#include "lcd_display.h"

#pragma pack(1)

/* 消息 */
enum
{
	MSG_PERIOD_1S = 1,	        /* 1S周期事件 */
	MSG_SYSTEM_START,	        /* 系统开始事件 */
	MSG_BLE_RB_DISCONNECT,      /* 跑步豆断开连接事件 */
	MSG_BLE_RB_CONNECT,         /* 跑步豆连接事件 */
	MSG_BLE_PAD_DISCONNECT,     /* PAD断开连接事件 */
	MSG_BLE_PAD_CONNECT,        /* PAD连接事件 */
	MSG_SPORT_START,            /* 开始上课事件 */
	MSG_SPORT_END,              /* 结束上课事件 */
	MSG_REC_ACC_DATA ,	        /* 接收ACC数据 */
	MSG_REC_GPS_DATA ,	        /* 接收GPS数据 */
	MSG_PRESS_KEY ,	            /* 按键事件 */
};

typedef struct
{
    uint8_t         u8Event;
    uint8_t         u8Parameter1;
    uint8_t*        pdata;
} SYSTEM_MNG_EVENT_MSG;


typedef struct
{
    int16_t     acc_x;
    int16_t     acc_y;
    int16_t     acc_z;
}ACC_DATA_T;

#pragma pack()

extern uint32_t ble_data_send(uint8_t* p_data, uint16_t p_length);

extern bool g_sleep_mode;
extern bool g_enter_sleep;
extern uint8_t g_sport_data_rt_index;

static ACC_DATA_T acc_buf[21]   = {0};      //用于存储接收到的ble发送过来的acc数据
static uint8_t acc_buf_index    = 0;

//定时器
extern TimerHandle_t timer_sport;

static QueueHandle_t Queue_sys_mng_msg = NULL;

//定时器周期：100ms
#define TIMER_PERIOD_100MS      pdMS_TO_TICKS(100)

//定时器周期：1000ms
#define TIMER_PERIOD_1000MS      pdMS_TO_TICKS(1000)

//定时器周期：10ms
#define TIMER_PERIOD_10MS      pdMS_TO_TICKS(10)

extern bool g_ble_pad_connect;

uint32_t g_auto_power_off_cnt = 0;

uint8_t g_heart_value               = 0;        //记录心率值
uint8_t g_heart_value_update_cnt    = 0;        //用于心率值更新超时记录


ble_date_time_t time_local = {0};
bool btime_syc_flag = false;

extern bool gs_start;

//结束上课后的数据存储完成标志位
bool sport_data_saved = true;

extern void bat_manager_init(void);
extern void lcd_display_init(void);
extern void bat_timer_handler(void);
extern void ble_disconnect_all(void);
extern void sh8501a0_uninit(void);
extern void advertising_init(void);
extern void scan_start(void);
extern void data_collect_Acc(int16_t i16acc_x, int16_t i16acc_y, int16_t i16acc_z);
extern void data_collect_GPS(double GPS_Lat, double GPS_Lon);
extern void adv_update(void);

void task_sys_mng_Message_Send(SYSTEM_MNG_EVENT_MSG Message);

//extern uint32_t rtc_counter_get(void);


void printbuf(uint8_t *u8buf, size_t len)
{
    if (NULL == u8buf)
    {
        return;
    }

    for (uint16_t i = 0; i < len; i++)
    {
        NRF_LOG_INFO("0x%.2x, ", u8buf[i]);
    }
}

void flash_test(void)
{
    uint8_t Tx_Buffer[16] = {0};
    uint8_t Rx_Buffer[16] = {0};
    uint8_t i = 0;

    NRF_LOG_INFO("flash_test start");

#if 1

#if 1
    Flash_Erase_Sector(0);  //写之前必须先擦除sector
    
    NRF_LOG_INFO("Flash_Erase_Sector.");
    nrf_delay_ms(10);  
    
    for (i = 0; i < sizeof(Tx_Buffer); i++)
    {
        Tx_Buffer[i] = i + 1;
    }
    printbuf(Tx_Buffer, sizeof(Tx_Buffer));
    
    Flash_Write(Tx_Buffer, 0x100, sizeof(Tx_Buffer));    //写入5个字节数据
#endif    
    for (i = 0; i < sizeof(Rx_Buffer); i++)
    {
        Rx_Buffer[i] = 0; //清零Flash_WR_Buf                                                
    }
    
    Flash_Read(Rx_Buffer, 0x100, sizeof(Rx_Buffer));      //读出5个字节数据
    NRF_LOG_INFO("Read data = ");

    printbuf(Rx_Buffer, sizeof(Rx_Buffer));
#if 0
    for(i = 0; i < 20; i++)
    {
        NRF_LOG_INFO("%c", (uint8_t)Rx_Buffer[i]);  //串口打印从FLASH读出的数据
    }
#endif
    nrf_delay_ms(100);
#endif
}


/**@brief Function for putting the chip into sleep mode.
 *
 * @note This function will not return.
 */
static void sleep_mode_enter(void)//随眠模式进入
{
    uint32_t err_code;
    
    g_sleep_mode = true;

    //关闭屏幕
    sh8501a0_uninit();
    
    while (false == g_enter_sleep)
    {
        nrf_delay_ms(10);
    }

    //等待上课数据存储完
    while (false == sport_data_saved)
    {
        nrf_delay_ms(10);
    }

    //主动断开蓝牙连接
    ble_disconnect_all();
    
    //关心率
	hr_task_msg_send(HR_EVT_SLEEP);

    //关功放
    wm8978_PowerDown();

    //延时确保都关闭
    nrf_delay_ms(100);
    
    //flash
    SPI_Flash_Deinit();


    // 设置按键唤醒.
//    err_code = bsp_btn_ble_sleep_mode_prepare();
//    APP_ERROR_CHECK(err_code);

    //设置充电唤醒，当前没有在充电，则充电唤醒，当前已经在充电，咋取消充电唤醒
    if (0 == bat_get_charging_stat())
    {
        nrf_gpio_cfg_sense_set(BAT_CHG_PIN, NRF_GPIO_PIN_SENSE_LOW);
    }
    else
    {
        nrf_gpio_cfg_sense_set(BAT_CHG_PIN, NRF_GPIO_PIN_SENSE_HIGH);
    }

    // Go to system-off mode (this function will not return; wakeup will cause a reset).
    err_code = sd_power_system_off();
    APP_ERROR_CHECK(err_code);
}

static void time_local_update(void)
{
    ble_date_time_t * p_time = &time_local;
    p_time->seconds++;
    if (p_time->seconds > 59)
    {
        p_time->seconds = 0;
        p_time->minutes++;
        if (p_time->minutes > 59)
        {
            p_time->minutes = 0;
            p_time->hours++;
            if (p_time->hours > 24)
            {
                p_time->hours = 0;
                p_time->day++;
                if (p_time->day > 31)
                {
                    p_time->day = 0;
                    p_time->month++;
                    if (p_time->month > 12)
                    {
                        p_time->year++;
                    }
                }
            }
        }
    }
}

uint32_t GET_UTC(void)
{
    return 0;
}

//*****************************************************************************
// * 函 数 名  : timer_sport_handler
// * 函数功能  : 运动数据周期处理用定时器，周期1s
// * 输入参数  :	 无
// * 输出参数  : 无
// * 返 回 值  : 无
//*****************************************************************************/
void timer_sport_handler(nrf_timer_event_t event_type, void * p_context)
{
    //更新运动时长
    g_sport_data.u32time_Sec++;

    //运动数据更新处理
    
}

//*****************************************************************************
// * 函 数 名  : sys_mng_period_1s_handler
// * 函数功能  : 1s周期处理:电池信息管理、时间刷新、自动休眠管理
// * 输入参数  :	 无
// * 输出参数  : 无
// * 返 回 值  : 无
//*****************************************************************************/
static void sys_mng_period_1s_handler(void)
{
    //电池信息处理
    bat_timer_handler();

    //时间处理
    time_local_update();


    //上课状态或数据同步中不做自动休眠关机
    if (false == allow_sleep())
    {
        g_auto_power_off_cnt = 0;
    }
    else
    {
        if (g_auto_power_off_cnt++ >= POWER_OFF_TIME_CNT)
        {
            //自动休眠
            sleep_mode_enter();
        }
    }

//    NRF_LOG_INFO("sys_mng_period_1s_handler: g_auto_power_off_cnt = %u", g_auto_power_off_cnt);

}


//*****************************************************************************
// * 函 数 名  : sport_his_data_upload
// * 函数功能  : 按指定索引上传历史记录历史运动数据上传
// * 输入参数  :	 无
// * 输出参数  : 无
// * 返 回 值  : 无
//*****************************************************************************/
void sport_his_data_upload(uint8_t u8index)
{
    //上传实时速度数据
    sports_data_rt_upload(u8index);
}



//*****************************************************************************
// * 函 数 名  : timer_100ms_handle
// * 函数功能  : 100ms周期定时器
// * 输入参数  :	 无
// * 输出参数  : 无
// * 返 回 值  : 无
//*****************************************************************************/
void timer_100ms_handle(TimerHandle_t xTimer)
{
    UNUSED_PARAMETER(xTimer);
    
//    uint32_t enterTime = nrf_rtc_counter_get(portNRF_RTC_REG);

//    NRF_LOG_INFO("enterTime = %d", enterTime);

    static uint8_t time_cnt = 0;
    time_cnt++;

    //开启3轴数据采集
    if (gs_start)
    {
        //心率需要的3轴数据采集
        hr_task_msg_send(HR_EVT_ACC_COLLECT);
//        app_gs_acc_collect();

    }

    //每秒刷新一次
    if (0 == time_cnt % 10)
    {
        SYSTEM_MNG_EVENT_MSG Message    = {0};
        Message.u8Event                 = MSG_PERIOD_1S;

        //发送主任务1s事件
        task_sys_mng_Message_Send(Message);


        //更新训练时长
		if (0x01 == m_bracelet_state.train_state)
		{
		    m_bracelet_state.train_sec++;
		}
		else if (0x00 == m_bracelet_state.train_state)
		{
		    m_bracelet_state.train_sec = 0;
		}

    }
    else if (0 == time_cnt % 3)
    {
        //发送刷屏消息，300ms一次
        task_display_Message_Send(0xAA);
    }
}

//*****************************************************************************
// * 函 数 名  : timer_10ms_handle
// * 函数功能  : 10ms周期定时器
// * 输入参数  :	 无
// * 输出参数  : 无
// * 返 回 值  : 无
//*****************************************************************************/
void timer_10ms_handle(TimerHandle_t xTimer)
{
    UNUSED_PARAMETER(xTimer);
    for(uint8_t i=0;i<240;i++)
    {
        test_send_data[i]=i+1;
    }
    ble_data_send(test_send_data,240);
}

//*****************************************************************************
// * 函 数 名  : task_sys_mng_Message_Send
// * 函数功能  : 设备管理模块发送消息处理函数
// * 输入参数  :	 Message：消息
// * 输出参数  : 无
// * 返 回 值  : 无
//*****************************************************************************/
void task_sys_mng_Message_Send(SYSTEM_MNG_EVENT_MSG Message)
{
//    NRF_LOG_INFO("task_display_Message_Send");
    //发出消息
    if (NULL != Queue_sys_mng_msg)
    {
        xQueueSend(Queue_sys_mng_msg, &Message, 0);
    }
}

//*****************************************************************************
// * 函 数 名  : task_sys_mng_Message_SendFromISR
// * 函数功能  : 设备管理模块发送消息处理函数，从中断发送使用
// * 输入参数  :	 Message：消息
// * 输出参数  : 无
// * 返 回 值  : 无
//*****************************************************************************/
void task_sys_mng_Message_SendFromISR(SYSTEM_MNG_EVENT_MSG Message)
{
//    NRF_LOG_INFO("task_display_Message_Send");
    //发出消息
    if (NULL != Queue_sys_mng_msg)
    {
        xQueueSendFromISR(Queue_sys_mng_msg, &Message, 0);
    }
}


//*****************************************************************************
// * 函 数 名  : task_sys_mng_handle
// * 函数功能  : 设备管理任务处理
// * 输入参数  :	 无
// * 输出参数  : 无
// * 返 回 值  : 无
//*****************************************************************************/
void task_sys_mng_handle(void * arg)
{
    UNUSED_PARAMETER(arg);

    acc_buf_index = 0;
    
    SYSTEM_MNG_EVENT_MSG EventMsg = {0};

    Queue_sys_mng_msg = xQueueCreate(10, sizeof(EventMsg));

    //启动系统事件
    EventMsg.u8Event = MSG_SYSTEM_START;
	task_sys_mng_Message_Send(EventMsg);

	EventMsg.u8Event = 0;

    while (1)
    {
        if (pdPASS == xQueueReceive(Queue_sys_mng_msg, &EventMsg, 100/portTICK_PERIOD_MS))
        {
            switch (EventMsg.u8Event)
            {
                case MSG_SYSTEM_START:
                {
                    //设置充电唤醒和按键唤醒
                    nrf_gpio_cfg_sense_set(BAT_CHG_PIN, NRF_GPIO_PIN_SENSE_LOW);
                    bsp_btn_ble_sleep_mode_prepare();

                    //开启广播和搜素
                    advertising_start();
                    scan_start();
                    
                    sport_data_saved = true;
                    
                    class_start();
                }
                break;
            
                case MSG_PERIOD_1S:
                {
                    //1s周期处理
                    sys_mng_period_1s_handler();      
                  
                    save_flash_data();   
                    if(g_heart_value > 170)
                    {
                        //心率报警
                    }
                    
                    #if 1
                    //动态广播
                    if (false == g_ble_pad_connect)
                    {
                        adv_update();
                    }
                    #endif
                }
                break;

                case MSG_REC_ACC_DATA:
                {
                    ACC_DATA_T* pAcc_data   = (ACC_DATA_T*)EventMsg.pdata;
                    uint8_t  acc_data_cnt   = EventMsg.u8Parameter1;

                    for (uint8_t i = 0; i < acc_data_cnt; i++)
                    {
                        data_collect_Acc(pAcc_data[i].acc_x, pAcc_data[i].acc_y, pAcc_data[i].acc_z);
                    }

                    free(EventMsg.pdata);
                }
                break;

                case MSG_REC_GPS_DATA:
                {
                    double* lat = (double*)EventMsg.pdata;
                    double* lon = (double*)(EventMsg.pdata+sizeof(double));

                    data_collect_GPS(*lat, *lon);

                    free(EventMsg.pdata);
                }
                break;

                case MSG_SPORT_START:
                {
                    //设置上课数据存储标志位
                    sport_data_saved = false;
                    
                    ret_code_t err_code;
                    
                    memset(&g_sport_data, 0, sizeof(g_sport_data));
                    g_sport_data.UTC = GET_UTC();
                    
                    // 启动运动用定时器
                    err_code = xTimerStart(timer_sport, 0);
                    if (pdPASS != err_code)
                    {
                        APP_ERROR_HANDLER(err_code);
                    }
                    save_data_flag = 1;
                    g_sport_data_rt_index = 0;
                    if (g_his_data_manager_info.u8his_cnt > 0)
                    {
                        sports_his_data_del();    
                    }

                    sport_data_init();
                }
                break;

                case MSG_SPORT_END:
                {
                    ret_code_t err_code;
                    save_data_flag = 0;
                    
                    //停止周期定时器
                    err_code = xTimerStop(timer_sport, 0);
                    if (pdPASS != err_code)
                    {
                        APP_ERROR_HANDLER(err_code);
                    }
                    
                    //更新本次运动总数据，并存储flash
                    
                    sport_data_end();
                    
                    his_data_manage_save();

                    //数据已经存储完，设置标志位
                    sport_data_saved = true;
                    
                }
                break;

                case MSG_BLE_RB_CONNECT:
                {
                    acc_buf_index = 0;
                }
                break;

                case MSG_BLE_RB_DISCONNECT:
                {
                    acc_buf_index = 0;
                }
                break;
                
                default:
                    break;
            }
        
        }
        
        EventMsg.u8Event = 0;
    }
}


#if 0
/******************************************************************************
* 函 数 名  : nmea_atof
* 函数功能	: 字符串转double数字，网上找的
* 输入参数	: str：要转的字符串； str_sz字符串长度
* 输出参数	: 无
* 返 回 值  : 转换的double型数字
******************************************************************************/
static double nmea_atof(const char *str, uint8_t str_sz)
{
    char *tmp_ptr;
    char buff[15];
    double res = 0;

    if(str_sz < 15)
    {
        memcpy(&buff[0], str, str_sz);
        buff[str_sz] = '\0';
        res = strtod(&buff[0], &tmp_ptr);
    }

    return res;
}
#endif

double pow_double(double x, uint8_t y)
{
    double res = 1;
    
    for (uint8_t i = 0; i < y; i++)
    {
        res = res * x;
    }

    return res;
}

//*****************************************************************************
// * 函 数 名  : str_to_lonlat
// * 函数功能  : 字符串转换为经纬度，以度为单位的经纬度
// * 输入参数  :	    str: 数据包
// *                len: 数据长度
// * 输出参数  : 无
// * 返 回 值  : 无
//*****************************************************************************/
double str_to_lonlat(uint8_t* str, size_t len)
{
    uint8_t u8dot_index     = 0;
    uint8_t i               = 0;

    double  du      = 0;
    double  fen     = 0;

    double  res     = 0;

    //先查找dot
    for (u8dot_index = 0; u8dot_index < len; u8dot_index++)
    {
        if ('.' == str[u8dot_index])
        {
            break;
        }
    }

    //非法的度分格式经纬度
    if ((u8dot_index >= len) || (u8dot_index < 2))
    {
        return 360;
    }

    //提取度
    for (i = 0; i < (u8dot_index - 2); i++)
    {
        du = du * 10;
        du += str[i] - '0';
    }

    //提取分
    fen = (str[u8dot_index - 2] - '0') * 10 + (str[u8dot_index - 1] - '0');
    
    for (i = u8dot_index + 1; i < len; i++)
    {
        fen += (double)(str[i] - '0')/pow_double(10, i - u8dot_index);
    }

    //转换为度分格式经纬度
    res = du + fen/60;

    return res;
    
}

//*****************************************************************************
// * 函 数 名  : str_to_time
// * 函数功能  : 字符串转换为时间
// * 输入参数  :	    str: 数据包
// *                len: 数据长度
// * 输出参数  : 无
// * 返 回 值  : 无
//*****************************************************************************/
void str_to_time(uint8_t* str, size_t len)
{
    /************************************************/
    //时间格式：hhmmss.sssddmmyy， .固定在第6个索引的位置
    /************************************************/

    //有效性校验
    for (uint8_t i = 0; i < len; i++)
    {
        //.固定在第6个索引的位置
        if (6 == i)
        {
            if ('.' != str[i])
            {
                return;
            }
        }
        //所有均为数字
        else if ((str[0] < '0') || (str[0] > '9'))
        {
            return;
        }
    }

    time_local.hours     = 10*(str[0] - '0') + (str[1] - '0');
    time_local.minutes   = 10*(str[2] - '0') + (str[3] - '0');
    time_local.seconds   = 10*(str[4] - '0') + (str[5] - '0');
    time_local.day       = 10*(str[10] - '0') + (str[11] - '0');
    time_local.month     = 10*(str[12] - '0') + (str[13] - '0');
    time_local.year      = 2000 + 10*(str[14] - '0') + (str[15] - '0');

    btime_syc_flag = true;

//    NRF_LOG_INFO("date = %d.%d.%d", time_local.year, time_local.month, time_local.day);
//    NRF_LOG_INFO("time = %d:%d:%d", time_local.hours, time_local.minutes, time_local.seconds);
    
}


//*****************************************************************************
// * 函 数 名  : running_bean_data_handle
// * 函数功能  : 接收处理跑步豆上传过来的acc和gps数据
// * 输入参数  :	    pdata: 数据包
// *                len: 数据长度
// * 输出参数  : 无
// * 返 回 值  : 无
//*****************************************************************************/
void running_bean_data_handle(uint8_t* pdata, uint8_t len)
{
    static double gps_Lat = 0;
    static double gps_Lon = 0;

    SYSTEM_MNG_EVENT_MSG Message    = {0};
    uint16_t u16data_len            = 0;
    uint8_t* databuff               = NULL;

    uint8_t u8RMC_A             = 0;
    uint8_t u8RunningBean_bat   = 0;
    
    int16_t acc_x = 0;
    int16_t acc_y = 0;
    int16_t acc_z = 0;

    //无效数据
    if (0xAA != pdata[0])
    {
        return;
    }
    
    uint32_t enterTime = nrf_rtc_counter_get(portNRF_RTC_REG);
    
    //AA B0，ACC数据
    if (0xB0 == pdata[1])
    {
        //GPS RMC中状态信息
        u8RMC_A             = pdata[2];
        gps_connect_flag    = u8RMC_A;
        //跑步豆电量信息
        u8RunningBean_bat   = pdata[3];

        //acc数据
        acc_x = pdata[5];
        acc_x = (acc_x << 8) | pdata[4];

        acc_y = pdata[7];
        acc_y = (acc_y << 8) | pdata[6];

        acc_z = pdata[9];
        acc_z = (acc_z << 8) | pdata[8];

        acc_buf[acc_buf_index].acc_x = acc_x;
        acc_buf[acc_buf_index].acc_y = acc_y;
        acc_buf[acc_buf_index].acc_z = acc_z;

        acc_buf_index++;
        
        if (acc_buf_index >= 20)
        {

            u16data_len = acc_buf_index * sizeof(ACC_DATA_T);
            databuff    = (uint8_t *)malloc(u16data_len);
            
            if(databuff == NULL)
            {
                return;
            }

            memcpy(databuff, acc_buf, u16data_len);

            Message.u8Event         = MSG_REC_ACC_DATA;
            Message.u8Parameter1    = acc_buf_index;
            Message.pdata           = databuff;

            task_sys_mng_Message_SendFromISR(Message);

            acc_buf_index = 0;
        }

//        data_collect_Acc(acc_x, acc_y, acc_z);
        
//        NRF_LOG_INFO("acc = %d, %d, %d", acc_x, acc_y, acc_z);

    }
    //AA B1，经纬度数据
    else if (0xB1 == pdata[1])
    {
        if(isMove == 1)
        {
            gps_Lat = str_to_lonlat((pdata + 2), 10);
        
            gps_Lon = str_to_lonlat((pdata + 12), 10);
   
            u16data_len = 2 * sizeof(double);
            databuff    = (uint8_t *)malloc(u16data_len);
        
            if(databuff == NULL)
            {
                return;
            }
        
            memcpy(databuff, &gps_Lat, sizeof(double));
            memcpy(databuff + sizeof(double), &gps_Lon, sizeof(double));

            Message.u8Event = MSG_REC_GPS_DATA;
            Message.pdata   = databuff;
        
            task_sys_mng_Message_SendFromISR(Message);
        }
        
//        data_collect_GPS(gps_Lat, gps_Lon);

//        NRF_LOG_INFO("weidu = " NRF_LOG_FLOAT_MARKER "\r\n", NRF_LOG_FLOAT(gps_Lat));
//        NRF_LOG_INFO("jingdu = " NRF_LOG_FLOAT_MARKER "\r\n", NRF_LOG_FLOAT(gps_Lon));

        //解析UTC时间和日期
        if (false == btime_syc_flag)
        {
            str_to_time((pdata + 22), 16);
        }
    }

}

//*****************************************************************************
// * 函 数 名  : ble_rb_connect_state_notify
// * 函数功能  : 跑步豆连接状态通知
// * 输入参数  :	    connect: true:连接； false: 未连接
// * 输出参数  : 无
// * 返 回 值  : 无
//*****************************************************************************/
void ble_rb_connect_state_notify(bool connect)
{
    SYSTEM_MNG_EVENT_MSG Message = {0};
    if (connect)
    {
        Message.u8Event = MSG_BLE_RB_CONNECT;
    }
    else
    {
        Message.u8Event = MSG_BLE_RB_DISCONNECT;
    }
    
    task_sys_mng_Message_SendFromISR(Message);
}

//*****************************************************************************
// * 函 数 名  : ble_pad_connect_state_notify
// * 函数功能  : pad连接状态通知
// * 输入参数  :	    connect: true:连接； false: 未连接
// * 输出参数  : 无
// * 返 回 值  : 无
//*****************************************************************************/
void ble_pad_connect_state_notify(bool connect)
{
    SYSTEM_MNG_EVENT_MSG Message = {0};
    if (connect)
    {
        Message.u8Event = MSG_BLE_PAD_CONNECT;
    }
    else
    {
        Message.u8Event = MSG_BLE_PAD_DISCONNECT;
    }
    
    task_sys_mng_Message_SendFromISR(Message);
}

//*****************************************************************************
// * 函 数 名  : sport_start
// * 函数功能  : 开始运动
// * 输入参数  :	 无
// * 输出参数  : 无
// * 返 回 值  : 无
//*****************************************************************************/
uint8_t sport_start(void)
{
    //历史记录达到上限，不允许开始新的运动
    if (g_his_data_manager_info.u8his_cnt >= HIS_DATA_CNT_MAX)
    {
        return 1;
    }

    SYSTEM_MNG_EVENT_MSG Message = {0};
    Message.u8Event = MSG_SPORT_START;
    
    task_sys_mng_Message_SendFromISR(Message);
    return 0;
}

//*****************************************************************************
// * 函 数 名  : sport_end
// * 函数功能  : 结束运动
// * 输入参数  :	 无
// * 输出参数  : 无
// * 返 回 值  : 无
//*****************************************************************************/
void sport_end(void)
{
    SYSTEM_MNG_EVENT_MSG Message = {0};
    Message.u8Event = MSG_SPORT_END;
    
    task_sys_mng_Message_SendFromISR(Message);
    
}

